package core

import (
	"context"
	"fmt"
	"time"

	"github.com/asynkron/protoactor-go/actor"
)

// System 是DataFlare系统的核心接口
type System interface {
	// Start 启动系统
	Start(ctx context.Context) error
	// Stop 停止系统
	Stop(ctx context.Context) error
	// GetActorFactory 获取Actor工厂
	GetActorFactory() ActorFactory
	// GetSystemSupervisor 获取系统监督者
	GetSystemSupervisor() ActorRef
	// GetWorkflowSupervisor 获取工作流监督者
	GetWorkflowSupervisor() ActorRef
	// GetStateManager 获取状态管理器
	GetStateManager() ActorRef
	// GetMetricsCollector 获取指标收集器
	GetMetricsCollector() ActorRef
}

// SystemImpl 是System的实现
type SystemImpl struct {
	// actorSystem 是底层的Actor系统
	actorSystem *actor.ActorSystem
	// actorFactory 是Actor工厂
	actorFactory ActorFactory
	// systemSupervisor 是系统监督者
	systemSupervisor ActorRef
	// workflowSupervisor 是工作流监督者
	workflowSupervisor ActorRef
	// stateManager 是状态管理器
	stateManager ActorRef
	// metricsCollector 是指标收集器
	metricsCollector ActorRef
}

// NewSystem 创建一个新的系统
func NewSystem() (System, error) {
	// 创建Actor系统
	actorSystem := actor.NewActorSystem()

	// 创建Actor工厂
	actorFactory := NewActorFactory(actorSystem)

	return &SystemImpl{
		actorSystem:  actorSystem,
		actorFactory: actorFactory,
	}, nil
}

// Start 启动系统
func (s *SystemImpl) Start(ctx context.Context) error {
	// 创建系统监督者
	systemSupervisorProps := actor.PropsFromProducer(func() actor.Actor {
		return NewSystemSupervisor()
	})

	systemSupervisorRef, err := s.actorFactory.CreateNamedActor(systemSupervisorProps, "system-supervisor")
	if err != nil {
		return err
	}
	s.systemSupervisor = systemSupervisorRef

	// 等待系统初始化完成
	time.Sleep(1 * time.Second)

	// 获取其他核心Actor
	s.workflowSupervisor, err = s.getChildActor("workflow-supervisor")
	if err != nil {
		return err
	}

	s.stateManager, err = s.getChildActor("state-manager")
	if err != nil {
		return err
	}

	s.metricsCollector, err = s.getChildActor("metrics-collector")
	if err != nil {
		return err
	}

	return nil
}

// Stop 停止系统
func (s *SystemImpl) Stop(ctx context.Context) error {
	// 停止系统监督者
	s.systemSupervisor.Tell(&actor.Stop{})

	// 等待系统关闭
	time.Sleep(1 * time.Second)

	return nil
}

// GetActorFactory 获取Actor工厂
func (s *SystemImpl) GetActorFactory() ActorFactory {
	return s.actorFactory
}

// GetSystemSupervisor 获取系统监督者
func (s *SystemImpl) GetSystemSupervisor() ActorRef {
	return s.systemSupervisor
}

// GetWorkflowSupervisor 获取工作流监督者
func (s *SystemImpl) GetWorkflowSupervisor() ActorRef {
	return s.workflowSupervisor
}

// GetStateManager 获取状态管理器
func (s *SystemImpl) GetStateManager() ActorRef {
	return s.stateManager
}

// GetMetricsCollector 获取指标收集器
func (s *SystemImpl) GetMetricsCollector() ActorRef {
	return s.metricsCollector
}

// getChildActor 获取子Actor
func (s *SystemImpl) getChildActor(name string) (ActorRef, error) {
	// 发送获取子Actor的请求
	response, err := s.systemSupervisor.Request(&GetChildRequest{Name: name}, 5000)
	if err != nil {
		return nil, err
	}

	// 解析响应
	getChildResponse, ok := response.(*GetChildResponse)
	if !ok {
		return nil, fmt.Errorf("unexpected response type: %T", response)
	}

	if !getChildResponse.Success {
		return nil, fmt.Errorf("failed to get child actor: %s", getChildResponse.Error)
	}

	return getChildResponse.Actor, nil
}

// SystemSupervisor 是系统监督者
type SystemSupervisor struct {
	// children 是子Actor
	children map[string]ActorRef
}

// NewSystemSupervisor 创建一个新的系统监督者
func NewSystemSupervisor() actor.Actor {
	return &SystemSupervisor{
		children: make(map[string]ActorRef),
	}
}

// Receive 处理消息
func (s *SystemSupervisor) Receive(context actor.Context) {
	switch msg := context.Message().(type) {
	case *actor.Started:
		s.handleStarted(context)
	case *actor.Stopping:
		s.handleStopping(context)
	case *GetChildRequest:
		s.handleGetChild(context, msg)
	default:
		// 未知消息
	}
}

// handleStarted 处理Started消息
func (s *SystemSupervisor) handleStarted(context actor.Context) {
	// 创建工作流监督者
	s.spawnWorkflowSupervisor(context)

	// 创建状态管理器
	s.spawnStateManager(context)

	// 创建指标收集器
	s.spawnMetricsCollector(context)
}

// handleStopping 处理Stopping消息
func (s *SystemSupervisor) handleStopping(context actor.Context) {
	// 停止所有子Actor
	for _, child := range s.children {
		child.Tell(&actor.Stop{})
	}
}

// handleGetChild 处理GetChildRequest消息
func (s *SystemSupervisor) handleGetChild(context actor.Context, msg *GetChildRequest) {
	// 查找子Actor
	child, ok := s.children[msg.Name]
	if !ok {
		// 子Actor不存在
		context.Respond(&GetChildResponse{
			Success: false,
			Error:   fmt.Sprintf("child actor not found: %s", msg.Name),
		})
		return
	}

	// 返回子Actor
	context.Respond(&GetChildResponse{
		Success: true,
		Actor:   child,
	})
}

// spawnWorkflowSupervisor 创建工作流监督者
func (s *SystemSupervisor) spawnWorkflowSupervisor(context actor.Context) {
	// 创建工作流监督者
	props := actor.PropsFromProducer(func() actor.Actor {
		return NewWorkflowSupervisor()
	})

	pid, err := context.SpawnNamed(props, "workflow-supervisor")
	if err != nil {
		// 创建失败
		return
	}

	// 保存引用
	s.children["workflow-supervisor"] = NewActorRef(pid, context.ActorSystem())
}

// spawnStateManager 创建状态管理器
func (s *SystemSupervisor) spawnStateManager(context actor.Context) {
	// 创建状态管理器
	props := actor.PropsFromProducer(func() actor.Actor {
		return NewStateManager()
	})

	pid, err := context.SpawnNamed(props, "state-manager")
	if err != nil {
		// 创建失败
		return
	}

	// 保存引用
	s.children["state-manager"] = NewActorRef(pid, context.ActorSystem())
}

// spawnMetricsCollector 创建指标收集器
func (s *SystemSupervisor) spawnMetricsCollector(context actor.Context) {
	// 创建指标收集器
	props := actor.PropsFromProducer(func() actor.Actor {
		return NewMetricsCollector()
	})

	pid, err := context.SpawnNamed(props, "metrics-collector")
	if err != nil {
		// 创建失败
		return
	}

	// 保存引用
	s.children["metrics-collector"] = NewActorRef(pid, context.ActorSystem())
}

// GetChildRequest 是获取子Actor的请求
type GetChildRequest struct {
	// Name 是子Actor的名称
	Name string
}

// GetChildResponse 是对GetChildRequest的响应
type GetChildResponse struct {
	// Success 表示操作是否成功
	Success bool
	// Error 是操作失败时的错误消息
	Error string
	// Actor 是子Actor
	Actor ActorRef
}

// WorkflowSupervisor 是工作流监督者
type WorkflowSupervisor struct {
	// 实现将在后续添加
}

// NewWorkflowSupervisor 创建一个新的工作流监督者
func NewWorkflowSupervisor() actor.Actor {
	return &WorkflowSupervisor{}
}

// Receive 处理消息
func (s *WorkflowSupervisor) Receive(context actor.Context) {
	// 实现将在后续添加
}

// StateManager 是状态管理器
type StateManager struct {
	// 实现将在后续添加
}

// NewStateManager 创建一个新的状态管理器
func NewStateManager() actor.Actor {
	return &StateManager{}
}

// Receive 处理消息
func (s *StateManager) Receive(context actor.Context) {
	// 实现将在后续添加
}

// MetricsCollector 是指标收集器
type MetricsCollector struct {
	// 实现将在后续添加
}

// NewMetricsCollector 创建一个新的指标收集器
func NewMetricsCollector() actor.Actor {
	return &MetricsCollector{}
}

// Receive 处理消息
func (m *MetricsCollector) Receive(context actor.Context) {
	// 实现将在后续添加
}
